﻿Imports Commander_Wars.Spieletools
Imports Microsoft.DirectX
Imports Microsoft.DirectX.Direct3D
Public Class ObjektLandschaft
    Implements ICloneable
#Region "Variablen"
#Region "Konstanten"
    Const MaximalesLeben As Integer = 100
    Public Shared UebergangsBreite As Integer = Hauptmenue.Feldbreite * 5 / 2
    Public Shared MaxFrames As Integer = 3
#End Region


    Public TerrainUntergrundID As Integer = -1
    Public TerrainUntergrundBildID As Integer = -1

    Public TerrainUntergrundID2 As Integer = -1
    Public TerrainUntergrundBildID2 As Integer = -1

    ''' <summary>
    ''' If we can see and move over this Tile...
    ''' </summary>
    ''' <remarks></remarks>
    Public Hidden As Boolean = False
    Private KP As Integer = -1
    Public Property Leben() As Integer
        Get
            Return KP
        End Get
        Set(ByVal value As Integer)
            KP += value
        End Set
    End Property
    Public Sub SetLeben(ByVal NeuLeben As Integer)
        KP = NeuLeben
    End Sub
    Private LandschaftsIDD As String
    Public Property LandschaftsID() As String
        Get
            Return LandschaftsIDD
        End Get
        Set(ByVal value As String)
            LandschaftsIDD = value
        End Set
    End Property
    ''' <summary>
    ''' Das Bild wird abgespeichert!
    ''' </summary>
    ''' <remarks></remarks>
    Private BildIDD As Integer
    Public Property BildID() As Integer
        Get
            Return BildIDD
        End Get
        Set(ByVal value As Integer)
            BildIDD = value
        End Set
    End Property
    ''' <summary>
    ''' Wenn true dann wird die Bild ID nicht neu berechnet
    ''' </summary>
    ''' <remarks></remarks>
    Public BildIDFest As Boolean = False
    Public Gebaeude As ObjektGebaeude
    Private Nebel As Nebelarten = Nebelarten.Aus
    Public Property Kriegsnebel() As Nebelarten
        Get
            Return Nebel
        End Get
        Set(ByVal value As Nebelarten)
            Nebel = value
        End Set
    End Property
    Public UebergangsIDS() As Integer = {}

    Dim Spieler As Integer = 0

    Public WirdZu As String = ""
    Private Landschaftsnamen As String
    Public Property Landschaftsname() As String
        Get
            Return Landschaftsnamen
        End Get
        Set(ByVal value As String)
            Landschaftsnamen = value
        End Set
    End Property
    Private IDD As Integer
    Public Property ID() As Integer
        Get
            Return IDD
        End Get
        Set(ByVal value As Integer)
            IDD = value
        End Set
    End Property
    Private Deckunge As Integer
    Public Property Deckung() As Integer
        Get
            If IsNothing(Gebaeude) Then
                Return Deckunge
            Else
                Return Gebaeude.Deckung
            End If
        End Get
        Set(ByVal value As Integer)
            Deckunge = value
        End Set
    End Property
    Public Tarnung As Boolean = False
    ''' <summary>
    ''' Gibt an in welchen Modus wir malen muessen.
    ''' </summary>
    ''' <remarks></remarks>
    Public Gross As Boolean = False
    Public Bewegungsrichtung As Integer = 0
    Public KooX As Integer = 0
    Public KooY As Integer = 0
    Private Shared LanfschaftsFrames As Integer = 0
    Public Shared HochZaehlen As Integer = -1
    Public Abflussrichtung As KompassRichtungen

    Public Shared Property Frame() As Integer
        Get
            Return LanfschaftsFrames
        End Get
        Set(ByVal value As Integer)
            'Andere Frames fuer Landschaften erhoehen.
            LandschaftsTexturFeuer.Frames_5 = 1
            LandschaftsTexturPlasma.Frames_2 = 1

            If HochZaehlen = 0 Then
                LanfschaftsFrames += 1
                If LanfschaftsFrames > MaxFrames Then
                    LanfschaftsFrames = 0
                End If
            Else
                LanfschaftsFrames += HochZaehlen
                If LanfschaftsFrames > MaxFrames Then
                    HochZaehlen = -1
                    LanfschaftsFrames += HochZaehlen * 2
                ElseIf LanfschaftsFrames < 0 Then
                    HochZaehlen = 1
                    LanfschaftsFrames += HochZaehlen * 2
                End If
            End If
        End Set
    End Property

#End Region
    Public Sub New(ByVal neuTyp As String, ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld, Optional ByVal neuGebaeude As ObjektGebaeude = Nothing)
        Gebaeude = neuGebaeude
        LandschaftsIDD = neuTyp
        Spieler = Zufallszahl(1, Spielfeld.Spieler.Length - 1)
        KooX = X
        KooY = Y
        Landschaftladen(X, Y, Spielfeld)
        If ID >= 0 Then
            WirdZu = Objektverwalter.LandschaftenBilder(ID).WirdZu
        End If
    End Sub


    Public Sub Write(ByRef StrW As Filestream, ByVal Schlacht As Integer, ByVal Landschaften() As String)
        If TerrainUntergrundID >= 0 Then
            StrW.WriteByte(255)
            Dim B(3) As Byte
            B = IntToBytes(TerrainUntergrundID)
            For I = 0 To B.Length - 1
                StrW.WriteByte(B(I))
            Next
            B = IntToBytes(TerrainUntergrundBildID)
            For I = 0 To B.Length - 1
                StrW.WriteByte(B(I))
            Next
        End If
        If TerrainUntergrundID2 >= 0 Then
            StrW.WriteByte(254)
            Dim B(3) As Byte
            B = IntToBytes(TerrainUntergrundID2)
            For I = 0 To B.Length - 1
                StrW.WriteByte(B(I))
            Next
            B = IntToBytes(TerrainUntergrundBildID2)
            For I = 0 To B.Length - 1
                StrW.WriteByte(B(I))
            Next
        End If

        If Schlacht = 0 Then
            If Hidden = False Then
                If KP >= 0 Then
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV1(StrW, Landschaften)
                        Else
                            WriteV2(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV3(StrW, Landschaften)
                        Else
                            WriteV4(StrW, Landschaften)
                        End If
                    End If
                Else
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV5(StrW, Landschaften)
                        Else
                            WriteV6(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV0(StrW, Landschaften)
                        Else
                            WriteV7(StrW, Landschaften)
                        End If
                    End If
                End If
            Else
                If KP >= 0 Then
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV8(StrW, Landschaften)
                        Else
                            WriteV9(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV10(StrW, Landschaften)
                        Else
                            WriteV11(StrW, Landschaften)
                        End If
                    End If
                Else
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV12(StrW, Landschaften)
                        Else
                            WriteV13(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV14(StrW, Landschaften)
                        Else
                            WriteV15(StrW, Landschaften)
                        End If
                    End If
                End If
            End If
        Else
            If Hidden = False Then
                If KP >= 0 Then
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV16(StrW, Landschaften)
                        Else
                            WriteV17(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV18(StrW, Landschaften)
                        Else
                            WriteV19(StrW, Landschaften)
                        End If
                    End If
                Else
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV20(StrW, Landschaften)
                        Else
                            WriteV21(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV22(StrW, Landschaften)
                        Else
                            WriteV23(StrW, Landschaften)
                        End If
                    End If
                End If
            Else
                If KP >= 0 Then
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV24(StrW, Landschaften)
                        Else
                            WriteV25(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV26(StrW, Landschaften)
                        Else
                            WriteV27(StrW, Landschaften)
                        End If
                    End If
                Else
                    If BildIDFest Then
                        If Nebel = Nebelarten.Aus Then
                            WriteV28(StrW, Landschaften)
                        Else
                            WriteV29(StrW, Landschaften)
                        End If
                    Else
                        If Nebel = Nebelarten.Aus Then
                            WriteV30(StrW, Landschaften)
                        Else
                            WriteV31(StrW, Landschaften)
                        End If
                    End If
                End If
            End If
        End If
    End Sub
    Private Sub WriteV1(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(1)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
    End Sub
    Private Sub WriteV2(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(2)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
    End Sub
    Private Sub WriteV3(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(3)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV4(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(4)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        StrW.WriteByte(Nebel)
    End Sub
    Private Sub WriteV5(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(5)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
    End Sub
    Private Sub WriteV6(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(6)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
    End Sub
    Private Sub WriteV0(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(0)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
    End Sub
    Private Sub WriteV7(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(7)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        StrW.WriteByte(Nebel)
    End Sub
    Private Sub WriteV8(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(8)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV9(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(9)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV10(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(10)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV11(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(11)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV12(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(12)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV13(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(13)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV14(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(14)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV15(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(15)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
    End Sub
    Private Sub WriteV16(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(16)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV17(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(17)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV18(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(18)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV19(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(19)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        StrW.WriteByte(Nebel)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV20(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(20)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV21(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(21)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV22(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(22)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV23(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(23)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        StrW.WriteByte(Nebel)
        Dim B(3) As Byte
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV24(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(24)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Hidden)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV25(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(25)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV26(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(26)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        StrW.WriteByte(Hidden)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV27(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(27)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(KP)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV28(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(28)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Hidden)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV29(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(29)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        Dim B(3) As Byte
        B = IntToBytes(IDD)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
        WriteIntegerArray(StrW, UebergangsIDS)
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV30(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(30)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        StrW.WriteByte(Hidden)
        Dim B(3) As Byte
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub
    Private Sub WriteV31(ByRef StrW As Filestream, ByVal Landschaften() As String)
        StrW.WriteByte(31)
        StrW.WriteByte(Array.IndexOf(Landschaften, LandschaftsIDD))
        StrW.WriteByte(Nebel)
        StrW.WriteByte(Hidden)
        Dim B(3) As Byte
        B = IntToBytes(Spieler)
        For I = 0 To B.Length - 1
            StrW.WriteByte(B(I))
        Next
    End Sub

    Public Shared Sub Read(ByRef StrR As Filestream, ByVal X As Integer, ByVal Y As Integer, ByVal Schlachtfeld As Integer, ByVal Spielfeld As ObjektSpielfeld, ByVal Landschaften() As String)
        Dim V As Byte = StrR.ReadByte
        Dim Untergrund As Integer = -1
        Dim UntergrundBild As Integer = -1
        Dim Untergrund2 As Integer = -1
        Dim UntergrundBild2 As Integer = -1
        If V = 255 Then
            Dim B(3) As Byte
            For I = 0 To B.Length - 1
                B(I) = StrR.ReadByte
            Next
            Untergrund = BytesToInt(B)
            For I = 0 To B.Length - 1
                B(I) = StrR.ReadByte
            Next
            UntergrundBild = BytesToInt(B)
            V = StrR.ReadByte
        End If
        If V = 254 Then
            Dim B(3) As Byte
            For I = 0 To B.Length - 1
                B(I) = StrR.ReadByte
            Next
            Untergrund2 = BytesToInt(B)
            For I = 0 To B.Length - 1
                B(I) = StrR.ReadByte
            Next
            UntergrundBild2 = BytesToInt(B)
            V = StrR.ReadByte
        End If
        Select Case V
            Case 1
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
            Case 2
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
            Case 3
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
            Case 4
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
            Case 5
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
            Case 6
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
            Case 0
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
            Case 7
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
            Case 8
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 9
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 10
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 11
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 12
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 13
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 14
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 15
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
            Case 16
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 17
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 18
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 19
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 20
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 21
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 22
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 23
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 24
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 25
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 26
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 27
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).KP = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 28
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 29
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).ID = BytesToInt(B)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).BildIDFest = True
                Spielfeld.Landschaften(X, Y, Schlachtfeld).UebergangsIDS = ReadIntegerArray(StrR)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 30
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
            Case 31
                Spielfeld.Landschaften(X, Y, Schlachtfeld) = New ObjektLandschaft(Landschaften(StrR.ReadByte), X, Y, Spielfeld)
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Kriegsnebel = StrR.ReadByte
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Hidden = StrR.ReadByte
                Dim B(3) As Byte
                For I = 0 To B.Length - 1
                    B(I) = StrR.ReadByte
                Next
                Spielfeld.Landschaften(X, Y, Schlachtfeld).Spieler = BytesToInt(B)
        End Select
        Spielfeld.Landschaften(X, Y, Schlachtfeld).TerrainUntergrundID = Untergrund
        Spielfeld.Landschaften(X, Y, Schlachtfeld).TerrainUntergrundBildID = UntergrundBild
        Spielfeld.Landschaften(X, Y, Schlachtfeld).TerrainUntergrundID2 = Untergrund2
        Spielfeld.Landschaften(X, Y, Schlachtfeld).TerrainUntergrundBildID2 = UntergrundBild2
    End Sub
#Region "Malen"
    Public Sub Landschaftladen(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld)
        For I = 0 To Objektverwalter.LandschaftenBilder.Length - 1
            If Objektverwalter.LandschaftenBilder(I).ID = LandschaftsIDD Then
                ID = I
                BildID = Objektverwalter.LandschaftenBilder(I).BildID(X, Y, Spielfeld)
                Landschaftsnamen = Objektverwalter.LandschaftenBilder(I).Landschaftsname
                Deckung = Objektverwalter.LandschaftenBilder(I).Deckung
                Tarnung = Objektverwalter.LandschaftenBilder(I).Tarnung
                KP = Objektverwalter.LandschaftenBilder(I).KP
                Gross = Objektverwalter.LandschaftenBilder(I).Gross
                WirdZu = Objektverwalter.LandschaftenBilder(I).WirdZu
                Dim Untergrund As String() = Objektverwalter.LandschaftenBilder(I).GetTerrainUntergrund
                If Untergrund.Length > 0 Then
                    For I2 = 0 To Objektverwalter.LandschaftenBilder.Length - 1
                        If Objektverwalter.LandschaftenBilder(I2).ID = Untergrund(0).ToUpper Then
                            TerrainUntergrundID = I2
                            TerrainUntergrundBildID = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).BildID(X, Y, Spielfeld, True)
                            Exit For
                        End If
                    Next
                End If
                If TerrainUntergrundID >= 0 Then
                    Untergrund = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).GetTerrainUntergrund
                    If Untergrund.Length > 0 Then
                        For I2 = 0 To Objektverwalter.LandschaftenBilder.Length - 1
                            If Objektverwalter.LandschaftenBilder(I2).ID = Untergrund(0).ToUpper Then
                                TerrainUntergrundID2 = I2
                                TerrainUntergrundBildID2 = 0
                                Exit For
                            End If
                        Next
                    End If
                End If
                If TerrainUntergrundID >= 0 Then
                    UebergangsIDS = Objektverwalter.LandschaftenBilder(I).UebergangsID(X, Y, Spielfeld)
                    If UebergangsIDS.Count = 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                        UebergangsIDS = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).UebergangsID(X, Y, Spielfeld)
                    End If
                Else
                    UebergangsIDS = Objektverwalter.LandschaftenBilder(I).UebergangsID(X, Y, Spielfeld)
                End If
                Exit For
            End If
        Next
    End Sub
    Public Sub UebergaengeAktualisieren(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld)
        If Not BildIDFest Then
            BildID = Objektverwalter.LandschaftenBilder(ID).BildID(X, Y, Spielfeld)

            Dim Untergrund As String() = Objektverwalter.LandschaftenBilder(ID).GetTerrainUntergrund
            If TerrainUntergrundID < 0 Then
                If Untergrund.Length > 0 Then
                    For I2 = 0 To Objektverwalter.LandschaftenBilder.Length - 1
                        If Objektverwalter.LandschaftenBilder(I2).ID = Untergrund(0).ToUpper Then
                            TerrainUntergrundID = I2
                            TerrainUntergrundBildID = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).BildID(X, Y, Spielfeld, True)
                            Exit For
                        End If
                    Next
                End If
            End If
            If TerrainUntergrundID >= 0 And TerrainUntergrundID2 < 0 Then
                Untergrund = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).GetTerrainUntergrund
                If Untergrund.Length > 0 Then
                    For I2 = 0 To Objektverwalter.LandschaftenBilder.Length - 1
                        If Objektverwalter.LandschaftenBilder(I2).ID = Untergrund(0).ToUpper Then
                            TerrainUntergrundID2 = I2
                            TerrainUntergrundBildID2 = 0
                            Exit For
                        End If
                    Next
                End If
            End If
            If TerrainUntergrundID >= 0 Then
                TerrainUntergrundBildID = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).BildID(X, Y, Spielfeld, True)
                UebergangsIDS = Objektverwalter.LandschaftenBilder(ID).UebergangsID(X, Y, Spielfeld)
                If TerrainUntergrundBildID2 < 0 And TerrainUntergrundID2 >= 0 Then TerrainUntergrundBildID2 = 0
                If UebergangsIDS.Count = 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                    UebergangsIDS = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).UebergangsID(X, Y, Spielfeld)
                End If
            Else
                UebergangsIDS = Objektverwalter.LandschaftenBilder(ID).UebergangsID(X, Y, Spielfeld)
            End If
        End If
    End Sub
    Public Sub RestoreLandschaft(ByVal LOriginal As ObjektLandschaft)
        BildIDFest = LOriginal.BildIDFest
        BildIDD = LOriginal.BildID
        Hidden = LOriginal.Hidden
        TerrainUntergrundID = LOriginal.TerrainUntergrundID
        TerrainUntergrundBildID = LOriginal.TerrainUntergrundBildID
        TerrainUntergrundID2 = LOriginal.TerrainUntergrundID2
        TerrainUntergrundBildID2 = LOriginal.TerrainUntergrundBildID2
        If TerrainUntergrundID < 0 Then
            Dim Untergrund As String() = Objektverwalter.LandschaftenBilder(ID).GetTerrainUntergrund
            If Untergrund.Length > 0 Then
                Dim UntergrundID As Integer = 0
                For I = 0 To Objektverwalter.LandschaftenBilder.Length - 1
                    If Objektverwalter.LandschaftenBilder(I).ID = Untergrund(0).ToUpper Then
                        UntergrundID = I
                        Exit For
                    End If
                Next
                TerrainUntergrundID = UntergrundID
                TerrainUntergrundBildID = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).BildID(LOriginal.KooX, LOriginal.KooY, Objektverwalter.Spielfeld, True)
            End If
            If TerrainUntergrundID >= 0 Then
                Untergrund = Objektverwalter.LandschaftenBilder(TerrainUntergrundID).GetTerrainUntergrund
                If Untergrund.Length > 0 Then
                    Dim UntergrundID As Integer = 0
                    For I = 0 To Objektverwalter.LandschaftenBilder.Length - 1
                        If Objektverwalter.LandschaftenBilder(I).ID = Untergrund(0).ToUpper Then
                            UntergrundID = I
                            Exit For
                        End If
                    Next
                    TerrainUntergrundID2 = UntergrundID
                    TerrainUntergrundBildID2 = 0
                End If
            End If
        End If
        If BildIDD >= Objektverwalter.LandschaftenBilder(ID).Texturen.Length Then
            BildIDFest = False
            UebergaengeAktualisieren(KooX, KooY, Objektverwalter.Spielfeld)
            BildIDFest = True
        End If
        UebergangsIDS = LOriginal.UebergangsIDS
    End Sub
    Public Sub Malen(ByVal X As Integer, ByVal Y As Integer, ByVal Alpha As Integer)
        'DataSettings._2D_3D_Malen = True
        If DataSettings.draw3D Then
            If Grafikengine.IsSphaereInFrustumPlane(New Vector3(X, 1, -Y), 2) Then
                'If Alpha < 255 Then Exit Sub 'Da ich noch nicht weiss, wie man auf transparente Dreiecke malt, lass ich die obere Luftschicht lieber weg, als alles damit zu ueberdecken.

                'Exit Sub
                Dim p_MatCube As Microsoft.DirectX.Matrix
                p_MatCube = Microsoft.DirectX.Matrix.RotationY(0)
                p_MatCube.M41 = KooX
                p_MatCube.M42 = 0
                p_MatCube.M43 = -KooY

                Objektverwalter.LandschaftenBilder(ID).Malen3D(p_MatCube, Me)
            End If
        ElseIf DataSettings._2D_3D_Malen Then
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            If Not DrawSpecialStyle(Alpha, False) Then
                Select Case Kriegsnebel
                    Case Nebelarten.Nebel
                        intColor = Color.FromArgb(Alpha, 180, 180, 180)
                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                        intColor = Color.FromArgb(Alpha, 120, 120, 120)
                End Select

                Dim Hoehe As Integer = 0
                Dim Breite As Single = 1
                Dim BreiteStart As Single = 0
                If Gross Then
                    Hoehe = 1
                End If
                If Objektverwalter.LandschaftenBilder(ID).Frame Then
                    Breite = 0.25
                    BreiteStart = Frame / 4
                End If

                Dim cube(3) As CustomVertex.PositionTextured
                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
                cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
                cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
                cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)

                Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Landschaften, KooY), cube, Objektverwalter.LandschaftenBilder(ID).Texturen(BildID), intColor)
            End If
            If Hauptmenue.Formmodus = Hauptmenue.Formmodi.Editor Then
                If BildIDFest Then
                    intColor = Color.FromArgb(Alpha, 255, 255, 255)
                    Dim Symbol As Integer = FindElement(Objektverwalter.Symbolfunktion, "KeineAutoLandschaft", True)
                    Dim cube(3) As CustomVertex.PositionTextured
                    cube(0) = New CustomVertex.PositionTextured(New Vector3(0, 0, 0), 0, 1)
                    cube(1) = New CustomVertex.PositionTextured(New Vector3(0, 0, 0.5), 0, 0)
                    cube(2) = New CustomVertex.PositionTextured(New Vector3(0.5, 0, 0), 1, 1)
                    cube(3) = New CustomVertex.PositionTextured(New Vector3(0.5, 0, 0.5), 1, 0)
                    Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Animationen * 4, KooY - 0.5), cube, Objektverwalter.Symbole(Symbol), intColor)
                End If
            End If
        Else
            'Mal sehen ob wir Speziell Malen sollen.
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            If Not DrawSpecialStyle(Alpha, False) Then
                'pruefen ob wir aus den Screenbereich laufen
                Select Case Kriegsnebel
                    Case Nebelarten.Nebel
                        intColor = Color.FromArgb(Alpha, 180, 180, 180)
                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                        intColor = Color.FromArgb(Alpha, 120, 120, 120)
                End Select

                'Festlegen welchen Bereich vom Bitmap wir kopieren

                'Welcher Teil der Textur soll gemalt werden Nichts bedeutet gesamtes Bild
                If Gross = False Then
                    With Grafikengine.recBild
                        .X = 0 : .Width = Hauptmenue.Feldbreite
                        .Y = 0 : .Height = Hauptmenue.Feldbreite
                    End With
                    With Grafikengine.ptfRotCenter
                        .X = Hauptmenue.Feldbreite / 2
                        .Y = Hauptmenue.Feldbreite / 2
                    End With
                    With Grafikengine.szfScale
                        .Height = Hauptmenue.Feldbreite
                        .Width = Hauptmenue.Feldbreite
                    End With
                Else
                    With Grafikengine.recBild
                        .X = 0 : .Width = Hauptmenue.Feldbreite
                        .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                    End With
                    With Grafikengine.ptfRotCenter
                        .X = Hauptmenue.Feldbreite / 2
                        .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                    End With
                    With Grafikengine.szfScale
                        .Height = Hauptmenue.Feldbreite * 2
                        .Width = Hauptmenue.Feldbreite
                    End With
                End If
                If Objektverwalter.LandschaftenBilder(ID).Frame Then
                    Grafikengine.recBild.X += Frame * Hauptmenue.Feldbreite
                End If
                'Falls der Zoomfaktor groesser 1 ist muessen einige Raender abgeschnitten werden
                'Hier befindet sich das Rotationszentrum
                'Achtung Rotationszentrum ist auch Ausgangspunkt der bemalung

                'Ausschnitte in den Backbuffer zeichnen
                'Wo wird das Bild gezeichnet
                Grafikengine.ptfPosition = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)

                '... und wie breit ist es

                'jetzt wird es in den Backbuffer gezeichnet
                Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Texturen(BildID), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
            End If
            If Hauptmenue.Formmodus = Hauptmenue.Formmodi.Editor Then
                If BildIDFest Then
                    intColor = Color.FromArgb(Alpha, 255, 255, 255)
                    Dim Symbol As Integer = FindElement(Objektverwalter.Symbolfunktion, "KeineAutoLandschaft", True)
                    Grafikengine.szfScale = Nothing
                    Grafikengine.recBild = Nothing
                    With Grafikengine.ptfRotCenter
                        .X = Hauptmenue.Feldbreite / 4
                        .Y = Hauptmenue.Feldbreite / 4
                    End With
                    Grafikengine.ptfPosition.X -= Hauptmenue.Feldbreite / 4
                    Grafikengine.ptfPosition.Y -= Hauptmenue.Feldbreite / 4
                    Grafikengine.Sprite.Draw2D(Objektverwalter.Symbole(Symbol), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                End If
            End If
        End If
    End Sub

    Public Function DrawSpecialStyle(ByVal Alpha As Integer, ByVal Top As Boolean) As Boolean
        Return Objektverwalter.LandschaftenBilder(ID).DrawSpecialStyle(BildID, Kriegsnebel, Alpha, KooX, KooY, TerrainUntergrundID, TerrainUntergrundBildID, TerrainUntergrundID2, TerrainUntergrundBildID2, False, Top)
    End Function

    ''' <summary>
    ''' Malt die Uebergaenge zu anderen Landschaften
    ''' </summary>
    ''' <remarks></remarks>
    Public Sub UebergaengeMalen(ByVal Alpha As Integer, ByVal X As Integer, ByVal Y As Integer)
        If Objektverwalter.LandschaftenBilder(ID).DrawUebergaenge Then
            If UebergangsIDS IsNot Nothing Then
                If DataSettings.draw3D Then

                ElseIf DataSettings._2D_3D_Malen Then
                    Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
                    Select Case Kriegsnebel
                        Case Nebelarten.Nebel
                            intColor = Color.FromArgb(Alpha, 180, 180, 180)
                        Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                            intColor = Color.FromArgb(Alpha, 120, 120, 120)
                        Case Else
                            intColor = Color.FromArgb(Alpha, 255, 255, 255)
                    End Select

                    Dim Hoehe As Integer = 0
                    Dim Breite As Single = 0.1
                    Dim BreiteStart As Single = 0

                    If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                        If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                Breite = Breite / 4
                                BreiteStart = Frame / 4
                            End If
                        ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                            Breite = Breite / 4
                            BreiteStart = Frame / 4
                        End If
                    ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                        Breite = Breite / 4
                        BreiteStart = Frame / 4
                    End If

                    Dim cube(3) As CustomVertex.PositionTextured
                    cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart + Breite * 3, 0.7)
                    cube(1) = New CustomVertex.PositionTextured(0, 0, 1, BreiteStart + Breite * 3, 0.3)
                    cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite * 3 + Breite * 4, 0.7)
                    cube(3) = New CustomVertex.PositionTextured(1, 0, 1, BreiteStart + Breite * 3 + Breite * 4, 0.3)
                    If Not Me.Hidden Then
                        'Die Mittelteile der Uebergaenge malen.
                        For I = 0 To UebergangsIDS.Length - 1
                            If UebergangsIDS(I) >= 0 Then
                                If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                    If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                        Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, KooY), cube, Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge(UebergangsIDS(I)), intColor)
                                    Else
                                        Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, KooY), cube, Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), intColor)
                                    End If
                                Else
                                    Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, KooY), cube, Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), intColor)
                                End If
                            End If
                        Next
                    End If
                    'Die 4 angrenzenden Felder
                    Dim L As ObjektLandschaft = Wegsuchsystem.getFeldRundrum(X, Y, Objektverwalter.Spielfeld.MomentaneSchlacht, 1, 1, Nothing, Objektverwalter.Spielfeld)
                    While L IsNot Nothing
                        If Not L.Hidden Then
                            Dim P As Vector3 = ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, KooY)
                            Select Case L.Kriegsnebel
                                Case Nebelarten.Nebel
                                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
                                Case Else
                                    intColor = Color.FromArgb(Alpha, 255, 255, 255)
                            End Select
                            If L.KooX > X Then
                                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 0.7)
                                cube(1) = New CustomVertex.PositionTextured(0, 0, 1, BreiteStart, 0.3)
                                cube(2) = New CustomVertex.PositionTextured(0.75, 0, 0, BreiteStart + Breite * 3, 0.7)
                                cube(3) = New CustomVertex.PositionTextured(0.75, 0, 1, BreiteStart + Breite * 3, 0.3)
                                P.X -= 0.75
                            ElseIf L.KooX < X Then
                                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart + Breite * 3 + Breite * 4, 0.7)
                                cube(1) = New CustomVertex.PositionTextured(0, 0, 1, BreiteStart + Breite * 3 + Breite * 4, 0.3)
                                cube(2) = New CustomVertex.PositionTextured(0.75, 0, 0, BreiteStart + Breite * 3 + Breite * 4 + Breite * 3, 0.7)
                                cube(3) = New CustomVertex.PositionTextured(0.75, 0, 1, BreiteStart + Breite * 3 + Breite * 4 + Breite * 3, 0.3)
                                P.X += 1
                            ElseIf L.KooY > Y Then
                                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart + Breite * 3, 1)
                                cube(1) = New CustomVertex.PositionTextured(0, 0, 0.75, BreiteStart + Breite * 3, 0.7)
                                cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite * 3 + Breite * 4, 1)
                                cube(3) = New CustomVertex.PositionTextured(1, 0, 0.75, BreiteStart + Breite * 3 + Breite * 4, 0.7)
                                P.Z -= 0.75
                            Else
                                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart + Breite * 3, 0.3)
                                cube(1) = New CustomVertex.PositionTextured(0, 0, 0.75, BreiteStart + Breite * 3, 0)
                                cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite * 3 + Breite * 4, 0.3)
                                cube(3) = New CustomVertex.PositionTextured(1, 0, 0.75, BreiteStart + Breite * 3 + Breite * 4, 0)
                                P.Z += 1
                            End If
                            P = ObjektSpielfeld.CalcDraw2D3DVec(P.X, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, -P.Z)
                            For I = 0 To UebergangsIDS.Length - 1
                                If UebergangsIDS(I) >= 0 Then
                                    If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                        If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                            Grafikengine.malen2Din3D(P, cube, Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge(UebergangsIDS(I)), intColor)
                                        Else
                                            Grafikengine.malen2Din3D(P, cube, Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), intColor)
                                        End If
                                    Else
                                        Grafikengine.malen2Din3D(P, cube, Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), intColor)
                                    End If
                                End If
                            Next
                        End If
                        L = Wegsuchsystem.getFeldRundrum(X, Y, Objektverwalter.Spielfeld.MomentaneSchlacht, 1, 1, L, Objektverwalter.Spielfeld)
                    End While
                    'Die 4 Ecken.
                    For I = 0 To 3
                        Dim P As Vector3 = ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, KooY)
                        Select Case I
                            Case 0
                                If Objektverwalter.Spielfeld.OnMap(X - 1, Y - 1) Then
                                    L = Objektverwalter.Spielfeld.Landschaften(X - 1, Y - 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                    cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 0.3)
                                    cube(1) = New CustomVertex.PositionTextured(0, 0, 0.75, BreiteStart, 0)
                                    cube(2) = New CustomVertex.PositionTextured(0.75, 0, 0, BreiteStart + Breite * 3, 0.3)
                                    cube(3) = New CustomVertex.PositionTextured(0.75, 0, 0.75, BreiteStart + Breite * 3, 0)
                                    P.X -= 0.75
                                    P.Z += 1
                                Else
                                    Continue For
                                End If
                            Case 1
                                If Objektverwalter.Spielfeld.OnMap(X + 1, Y - 1) Then
                                    L = Objektverwalter.Spielfeld.Landschaften(X + 1, Y - 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                    cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart + Breite * 7, 0.3)
                                    cube(1) = New CustomVertex.PositionTextured(0, 0, 0.75, BreiteStart + Breite * 7, 0)
                                    cube(2) = New CustomVertex.PositionTextured(0.75, 0, 0, BreiteStart + Breite * 10, 0.3)
                                    cube(3) = New CustomVertex.PositionTextured(0.75, 0, 0.75, BreiteStart + Breite * 10, 0)
                                    P.X += 1
                                    P.Z += 1
                                Else
                                    Continue For
                                End If
                            Case 2
                                If Objektverwalter.Spielfeld.OnMap(X - 1, Y + 1) Then
                                    L = Objektverwalter.Spielfeld.Landschaften(X - 1, Y + 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                    cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
                                    cube(1) = New CustomVertex.PositionTextured(0, 0, 0.75, BreiteStart, 0.7)
                                    cube(2) = New CustomVertex.PositionTextured(0.75, 0, 0, BreiteStart + Breite * 3, 1)
                                    cube(3) = New CustomVertex.PositionTextured(0.75, 0, 0.75, BreiteStart + Breite * 3, 0.7)
                                    P.X -= 0.75
                                    P.Z -= 0.75
                                Else
                                    Continue For
                                End If
                            Case 3
                                If Objektverwalter.Spielfeld.OnMap(X + 1, Y + 1) Then
                                    L = Objektverwalter.Spielfeld.Landschaften(X + 1, Y + 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                    cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart + Breite * 7, 1)
                                    cube(1) = New CustomVertex.PositionTextured(0, 0, 0.75, BreiteStart + Breite * 7, 0.7)
                                    cube(2) = New CustomVertex.PositionTextured(0.75, 0, 0, BreiteStart + Breite * 10, 1)
                                    cube(3) = New CustomVertex.PositionTextured(0.75, 0, 0.75, BreiteStart + Breite * 10, 0.7)
                                    P.X += 1
                                    P.Z -= 0.75
                                Else
                                    Continue For
                                End If
                        End Select
                        P = ObjektSpielfeld.CalcDraw2D3DVec(P.X, ObjektSpielfeld.SpielfeldLayer.Uebergaenge, -P.Z)
                        If Not L.Hidden Then
                            Select Case L.Kriegsnebel
                                Case Nebelarten.Nebel
                                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
                            End Select
                            For I2 = 0 To UebergangsIDS.Length - 1
                                If UebergangsIDS(I2) >= 0 Then
                                    If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                        If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                            Grafikengine.malen2Din3D(P, cube, Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge(UebergangsIDS(I2)), intColor)
                                        Else
                                            Grafikengine.malen2Din3D(P, cube, Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I2)), intColor)
                                        End If
                                    Else
                                        Grafikengine.malen2Din3D(P, cube, Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I2)), intColor)
                                    End If
                                End If
                            Next
                        End If
                    Next
                Else
                    If UebergangsIDS.Length > 0 Then
                        Dim sngRotation As Double = 0
                        Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
                        Grafikengine.szfScale = Nothing
                        Dim Randbreite As Integer = Hauptmenue.Feldbreite * 3 / 4
                        Dim SPunkt As Point = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
                        Grafikengine.ptfPosition = SPunkt
                        'zuerst die Mitte malen
                        Select Case Kriegsnebel
                            Case Nebelarten.Nebel
                                intColor = Color.FromArgb(Alpha, 180, 180, 180)
                            Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                                intColor = Color.FromArgb(Alpha, 120, 120, 120)
                            Case Else
                                intColor = Color.FromArgb(Alpha, 255, 255, 255)
                        End Select
                        With Grafikengine.recBild
                            .X = Randbreite : .Width = Hauptmenue.Feldbreite
                            .Y = Randbreite : .Height = Hauptmenue.Feldbreite
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = Hauptmenue.Feldbreite / 2
                            .Y = Hauptmenue.Feldbreite / 2
                        End With
                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                    Grafikengine.recBild.X += UebergangsBreite * Frame
                                End If
                            ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                Grafikengine.recBild.X += UebergangsBreite * Frame
                            End If
                        ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                            Grafikengine.recBild.X += UebergangsBreite * Frame
                        End If
                        If Not Me.Hidden Then
                            For I = 0 To UebergangsIDS.Length - 1
                                If UebergangsIDS(I) >= 0 Then
                                    If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                        If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge(UebergangsIDS(I)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                        Else
                                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                        End If
                                    Else
                                        Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                    End If
                                End If
                            Next
                        End If

                        'So und jetzt die Randlandschaften
                        Dim L As ObjektLandschaft = Wegsuchsystem.getFeldRundrum(X, Y, Objektverwalter.Spielfeld.MomentaneSchlacht, 1, 1, Nothing, Objektverwalter.Spielfeld)
                        While L IsNot Nothing
                            If Not L.Hidden Then
                                Grafikengine.ptfPosition = SPunkt
                                Select Case L.Kriegsnebel
                                    Case Nebelarten.Nebel
                                        intColor = Color.FromArgb(Alpha, 180, 180, 180)
                                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                                        intColor = Color.FromArgb(Alpha, 120, 120, 120)
                                    Case Else
                                        intColor = Color.FromArgb(Alpha, 255, 255, 255)
                                End Select
                                If L.KooX > X Then
                                    With Grafikengine.recBild
                                        .X = Randbreite + Hauptmenue.Feldbreite : .Width = Randbreite
                                        .Y = Randbreite : .Height = Hauptmenue.Feldbreite
                                    End With
                                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite / 2 + Randbreite / 2
                                ElseIf L.KooX < X Then
                                    With Grafikengine.recBild
                                        .X = 0 : .Width = Randbreite
                                        .Y = Randbreite : .Height = Hauptmenue.Feldbreite
                                    End With
                                    Grafikengine.ptfPosition.X -= (Hauptmenue.Feldbreite / 2 + Randbreite / 2)
                                ElseIf L.KooY > Y Then
                                    With Grafikengine.recBild
                                        .X = Randbreite : .Width = Hauptmenue.Feldbreite
                                        .Y = Randbreite + Hauptmenue.Feldbreite : .Height = Randbreite
                                    End With
                                    Grafikengine.ptfPosition.Y += (Hauptmenue.Feldbreite / 2 + Randbreite / 2)
                                Else
                                    With Grafikengine.recBild
                                        .X = Randbreite : .Width = Hauptmenue.Feldbreite
                                        .Y = 0 : .Height = Randbreite
                                    End With
                                    Grafikengine.ptfPosition.Y -= (Hauptmenue.Feldbreite / 2 + Randbreite / 2)
                                End If
                                'Jetzt das eigentliche Malen.
                                If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                    If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                        If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                            Grafikengine.recBild.X += UebergangsBreite * Frame
                                        End If
                                    ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                        Grafikengine.recBild.X += UebergangsBreite * Frame
                                    End If
                                ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                    Grafikengine.recBild.X += UebergangsBreite * Frame
                                End If
                                With Grafikengine.ptfRotCenter
                                    .X = Grafikengine.recBild.Width / 2
                                    .Y = Grafikengine.recBild.Height / 2
                                End With
                                For I = 0 To UebergangsIDS.Length - 1
                                    If UebergangsIDS(I) >= 0 Then
                                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                                Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge(UebergangsIDS(I)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                            Else
                                                Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                            End If
                                        Else
                                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                        End If
                                    End If
                                Next
                            End If
                            L = Wegsuchsystem.getFeldRundrum(X, Y, Objektverwalter.Spielfeld.MomentaneSchlacht, 1, 1, L, Objektverwalter.Spielfeld)
                        End While
                        'Die 4 aeusseren Ecken malen
                        Grafikengine.recBild.Size = New Size(Randbreite, Randbreite)
                        With Grafikengine.ptfRotCenter
                            .X = Randbreite / 2
                            .Y = Randbreite / 2
                        End With
                        For I = 0 To 3
                            Select Case I
                                Case 0
                                    If Objektverwalter.Spielfeld.OnMap(X - 1, Y - 1) Then
                                        L = Objektverwalter.Spielfeld.Landschaften(X - 1, Y - 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                        Grafikengine.ptfPosition = SPunkt + New Point(-Hauptmenue.Feldbreite / 2 - Randbreite / 2, -Hauptmenue.Feldbreite / 2 - Randbreite / 2)
                                        Grafikengine.recBild.Location = New Point(0, 0)
                                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                                    Grafikengine.recBild.X += UebergangsBreite * Frame
                                                End If
                                            ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                                Grafikengine.recBild.X += UebergangsBreite * Frame
                                            End If
                                        ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                            Grafikengine.recBild.X += UebergangsBreite * Frame
                                        End If
                                    Else
                                        Continue For
                                    End If
                                Case 1
                                    If Objektverwalter.Spielfeld.OnMap(X + 1, Y - 1) Then
                                        L = Objektverwalter.Spielfeld.Landschaften(X + 1, Y - 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                        Grafikengine.ptfPosition = SPunkt + New Point(+Hauptmenue.Feldbreite / 2 + Randbreite / 2, -Hauptmenue.Feldbreite / 2 - Randbreite / 2)
                                        Grafikengine.recBild.Location = New Point(UebergangsBreite - Randbreite, 0)
                                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                                    Grafikengine.recBild.X += UebergangsBreite * Frame
                                                End If
                                            ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                                Grafikengine.recBild.X += UebergangsBreite * Frame
                                            End If
                                        ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                            Grafikengine.recBild.X += UebergangsBreite * Frame
                                        End If
                                    Else
                                        Continue For
                                    End If
                                Case 2
                                    If Objektverwalter.Spielfeld.OnMap(X - 1, Y + 1) Then
                                        L = Objektverwalter.Spielfeld.Landschaften(X - 1, Y + 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                        Grafikengine.ptfPosition = SPunkt + New Point(-Hauptmenue.Feldbreite / 2 - Randbreite / 2, Hauptmenue.Feldbreite / 2 + Randbreite / 2)
                                        Grafikengine.recBild.Location = New Point(0, UebergangsBreite - Randbreite)
                                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                                    Grafikengine.recBild.X += UebergangsBreite * Frame
                                                End If
                                            ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                                Grafikengine.recBild.X += UebergangsBreite * Frame
                                            End If
                                        ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                            Grafikengine.recBild.X += UebergangsBreite * Frame
                                        End If
                                    Else
                                        Continue For
                                    End If
                                Case 3
                                    If Objektverwalter.Spielfeld.OnMap(X + 1, Y + 1) Then
                                        L = Objektverwalter.Spielfeld.Landschaften(X + 1, Y + 1, Objektverwalter.Spielfeld.MomentaneSchlacht)
                                        Grafikengine.ptfPosition = SPunkt + New Point(+Hauptmenue.Feldbreite / 2 + Randbreite / 2, Hauptmenue.Feldbreite / 2 + Randbreite / 2)
                                        Grafikengine.recBild.Location = New Point(UebergangsBreite - Randbreite, UebergangsBreite - Randbreite)
                                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame Then
                                                    Grafikengine.recBild.X += UebergangsBreite * Frame
                                                End If
                                            ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                                Grafikengine.recBild.X += UebergangsBreite * Frame
                                            End If
                                        ElseIf Objektverwalter.LandschaftenBilder(ID).Frame Then
                                            Grafikengine.recBild.X += UebergangsBreite * Frame
                                        End If
                                    Else
                                        Continue For
                                    End If
                            End Select
                            If Not L.Hidden Then
                                Select Case L.Kriegsnebel
                                    Case Nebelarten.Nebel
                                        intColor = Color.FromArgb(Alpha, 180, 180, 180)
                                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                                        intColor = Color.FromArgb(Alpha, 120, 120, 120)
                                End Select
                                For I2 = 0 To UebergangsIDS.Length - 1
                                    If UebergangsIDS(I2) >= 0 Then
                                        If TerrainUntergrundID >= 0 And Objektverwalter.LandschaftenBilder(ID).Uebergaenge.Count = 0 Then
                                            If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge.Count > 0 Then
                                                Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Uebergaenge(UebergangsIDS(I2)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                            Else
                                                Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I2)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                                            End If
                                        Else
                                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(ID).Uebergaenge(UebergangsIDS(I2)), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

                                        End If
                                    End If
                                Next
                            End If
                        Next
                    End If
                End If
            End If
        End If
    End Sub
    Public Sub WetterMalen()
        If Objektverwalter.Spielfeld.Regeln.Wetter > ObjektSpielfeld.Wetterarten.Sonne Then
            If DataSettings._2D_3D_Malen Then
                Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
                Select Case Kriegsnebel
                    Case Nebelarten.Nebel
                        intColor = Color.FromArgb(255, 180, 180, 180)
                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                        intColor = Color.FromArgb(255, 120, 120, 120)
                End Select

                Dim cube(3) As CustomVertex.PositionTextured
                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, 1 / 16 * Objektverwalter.Spielfeld.Wetterframe, 1)
                cube(1) = New CustomVertex.PositionTextured(0, 0, 1, 1 / 16 * Objektverwalter.Spielfeld.Wetterframe, 0)
                cube(2) = New CustomVertex.PositionTextured(1, 0, 0, 1 / 16 * Objektverwalter.Spielfeld.Wetterframe + 1 / 16, 1)
                cube(3) = New CustomVertex.PositionTextured(1, 0, 1, 1 / 16 * Objektverwalter.Spielfeld.Wetterframe + 1 / 16, 0)
                Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(KooX, ObjektSpielfeld.SpielfeldLayer.Wetter, KooY), cube, TexturenHalter.GetWetter(Objektverwalter.Spielfeld.Regeln.Wetter), intColor)
            Else
                Dim sngRotation As Double = 0
                Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
                Select Case Kriegsnebel
                    Case Nebelarten.Nebel
                        intColor = Color.FromArgb(255, 180, 180, 180)
                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                        intColor = Color.FromArgb(255, 120, 120, 120)
                End Select
                'pruefen ob wir aus den Screenbereich laufen

                'Festlegen welchen Bereich vom Bitmap wir kopieren

                'Welcher Teil der Textur soll gemalt werden Nichts bedeutet gesamtes Bild

                With Grafikengine.recBild
                    .X = Hauptmenue.FeldbreiteKlein * Objektverwalter.Spielfeld.Wetterframe : .Width = Hauptmenue.FeldbreiteKlein
                    .Y = 0 : .Height = Hauptmenue.FeldbreiteKlein
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.FeldbreiteKlein / 2
                    .Y = Hauptmenue.FeldbreiteKlein / 2
                End With
                '... und wie breit ist es
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite
                    .Width = Hauptmenue.Feldbreite
                End With
                Grafikengine.Sprite.Draw2D(TexturenHalter.GetWetter(Objektverwalter.Spielfeld.Regeln.Wetter), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
            End If
        End If
    End Sub
    ''' <summary>
    ''' Gibt den Spieler zurueck bei dem sich die Wolken bewegen
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetSpielerWolken() As Integer
        Return Spieler
    End Function
    ''' <summary>
    ''' Legt fest  den Spieler zurueck bei dem sich die Wolken bewegen
    ''' </summary>
    ''' <remarks></remarks>
    Public Sub SetSpielerWolken(ByVal Spieler As Integer)
        Me.Spieler = Spieler
    End Sub
#End Region
    Public Function getID() As String
        If IsNothing(Gebaeude) Then
            Return LandschaftsIDD
        Else
            Return Gebaeude.GebaeudeID
        End If
    End Function
    Public Function GetDeckung() As Integer
        If Objektverwalter.Spielfeld.Einheiten(KooX, KooY, Objektverwalter.Spielfeld.MomentaneSchlacht) Is Nothing Then
            If IsNothing(Gebaeude) Then
                Return Deckung
            Else
                Return Gebaeude.Deckung
            End If
        Else
            Return Objektverwalter.Spielfeld.Einheiten(KooX, KooY, Objektverwalter.Spielfeld.MomentaneSchlacht).GetSpieler.GetDeffensivSterne(Nothing, Me)
        End If
    End Function
    Public Function isGebaeude() As Boolean
        If Gebaeude Is Nothing Then
            Return False
        Else
            Return True
        End If
    End Function
    ''' <summary>
    ''' Returns the Unit on this Field based on the current shown Battle Map!
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetUnit() As ObjektEinheit
        Return Objektverwalter.Spielfeld.Einheiten(KooX, KooY, Objektverwalter.Spielfeld.MomentaneSchlacht)
    End Function
    Public Overridable Function GetMaxLeben() As Integer
        If Gebaeude Is Nothing Then
            If Leben > 0 Then
                Return 100
            Else
                Return 0
            End If
        Else
            Return Gebaeude.GetMaxLeben
        End If
    End Function
    ''' <summary>
    ''' Gibt das Leben der Landschaft bzw. des Gebaeudes zurueck.
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetLive() As Integer
        If Gebaeude Is Nothing Then
            Return Leben
        Else
            Return Gebaeude.GetKP(KooX, KooY, False)
        End If
    End Function
    ''' <summary>
    ''' Klont die gesamte Landschaft mit Gebaeude
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function Clone() As Object Implements System.ICloneable.Clone
        Dim L As ObjektLandschaft = MemberwiseClone()
        ReDim L.UebergangsIDS(UebergangsIDS.Length - 1)
        For I = 0 To UebergangsIDS.Length - 1
            L.UebergangsIDS(I) = UebergangsIDS(I)
        Next
        If Not Gebaeude Is Nothing Then
            L.Gebaeude = Gebaeude.Clone
        End If
        Return L
    End Function
End Class

